#include <stdio.h>

/* CORE CODE IN VANILLA C */

#include <string.h>
#define MAX_BIGNUM_LEN 40

int big_cmp(char *s, char *t)
{
	int ii, c = 0;
	for(ii = 0; s[ii] != '\0' || t[ii] != '\0'; ii++)
	{
		if(s[ii] == '\0') return -1;
		if(t[ii] == '\0') return 1;

		if(s[ii] != t[ii]) c = s[ii] - t[ii];
	}

	return c > 0 ? 1 : c == 0 ? 0 : -1;
}

void make_big(int a, char *s)
{
	int ii;
	for(ii = 0; a > 0; ii++, a /= 10)
		s[ii] = a%10 + '0';
	s[ii] = '\0';
}

int big_additive(char f, char *s, char *t, char *n) // n = s + t; n can be a ref. to a or b
{
	int c = 0, nxt = 0;

	for(;;s && s++, t && t++, n++)
	{
		s && (s = *s == '\0' ? NULL : s);
		t && (t = *t == '\0' ? NULL : t);

		if(!s && !t) break;

		s && (c += *s - '0');
		t && (f > 0 ? (c += *t - '0') : (c -= *t - '0'));
		c += nxt;
		nxt = 0;

		if(c < 0)
		{
			c += 10;
			nxt--;
		}

		*n = c % 10 + '0';
		c /= 10;
	}

	if(nxt < 0) return 1;

	if(c > 0)
		*(n++) = c + '0';
	for(; *(n-1) == '0'; *n--);
	*n = '\0';

	return 0;
}

void big_mult_add(char *s, char *t, char *n) // n += s * t; n != a, b
{
	char temp[MAX_BIGNUM_LEN], *ttemp = temp;
	int ii, c;

	for(; *t != '\0'; t++)
	{
		c = 0;
		for(ii = 0; s[ii] != '\0'; ii++)
		{
			c += (*t - '0') * (s[ii] - '0');
			ttemp[ii] = c%10 + '0';
			c /= 10;
		}

		if(c > 0)
			ttemp[ii++] = c + '0';
		ttemp[ii] = '\0';

		big_additive(1, temp, n, n);
		ttemp[0] = '0';
		ttemp++;
	}
}

/* C++ CLASS BINDINGS, WITH NEGATIVITY */

class Bignum	{
public:
	char vals[MAX_BIGNUM_LEN];
	char sign;

	Bignum() { vals[0] = '\0'; sign = 1; }
	Bignum(int n) {
		operator=(n);
	}

	void write(char *buff)	{
		int ii, jj, minus = sign < 0 && vals[0] != '\0';
		for(ii = 0; vals[ii] != '\0'; ii++);
		for(jj = minus, ii--; ii >= 0; ii--, jj++)
			buff[jj] = vals[ii];
		buff[jj] = '\0';
		if(minus) buff[0] = '-';
	}
	
	Bignum& operator+=(Bignum &other)	{
		char cmp;
		if(sign * other.sign > 0)
			big_additive(1, vals, other.vals, vals);
		else	{
			cmp = big_cmp(vals, other.vals);
			if(cmp >= 0)
				big_additive(-1, vals, other.vals, vals);
			else
				big_additive(-1, other.vals, vals, vals);

			if(cmp < 0) sign = -sign;
		}
		return *this;
	}

	Bignum& operator-=(Bignum &other)	{
		other.sign = -other.sign;
		(*this)+=(other);
		other.sign = -other.sign;

		return *this;
	}

	Bignum& operator=(Bignum &other)		{
		sign = other.sign;
		strcpy(vals, other.vals);
		return *this;
	}

	Bignum& operator=(int n)		{
		sign = n >= 0 ? 1 : -1;
		make_big(n >= 0 ? n : -n, vals);
		return *this;
	}

	Bignum& operator+(Bignum &other)		{
		Bignum *n = new Bignum;
		*n = *this;
		*n += other;
		return *n;
	}

	Bignum& operator-(Bignum &other)		{
		Bignum *n = new Bignum;
		*n = *this;
		*n -= other;
		return *n;
	}

	Bignum& operator*(Bignum &other)		{
		Bignum *n = new Bignum;
		big_mult_add(vals, other.vals, n->vals);
		n->sign = sign * other.sign;
		return *n;
	}

	int operator==(Bignum &other)	{
		if(sign != other.sign) return (vals[0] == '\0' && other.vals[0] == '\0');
		return (strcmp(vals, other.vals) == 0);
	}

	int operator>(Bignum &other)	{
		if(vals[0] == '\0' && other.vals[0] == '\0') return 0;
		if(sign > other.sign) return 1;
		if(sign < other.sign) return 0;
		return (big_cmp(vals, other.vals) * sign > 0);
	}

	int operator<(Bignum &other)	{ return other > *this; }
	int operator<=(Bignum &other)	{ return !(*this > other); }
	int operator>=(Bignum &other)	{ return !(*this < other); }
};

int main()
{
	int a, b;
	char c, buff[MAX_BIGNUM_LEN];
	Bignum p, q, r;

	scanf("%c %d %d", &c, &a, &b);
	p = a;
	q = b;

	if(c == '+')
		r = p+q;
	if(c == '-')
		r = p-q;
	if(c == '*')
		r = p*q;
	
	r.write(buff);
	printf("%s\n", buff);

	return 0;
}
